package com.kt.learn1

/**
 * Kotlin 协程示例
 * 包括协程的基本用法、挂起函数、协程上下文等
 */
import kotlinx.coroutines.*
import java.util.concurrent.Executors

fun main() {
    // 协程的基本用法
    chapter1BasicCoroutines()

    // 挂起函数
    chapter2SuspendFunctions()

    // 协程上下文和调度器
    chapter3CoroutineContextAndDispatchers()

    // 协程的作用域
    chapter4CoroutineScope()

    // 异常处理
    chapter5ExceptionHandling()

    // 协程中的并发和并行
    chapter6ConcurrencyAndParallelism()
}

// 协程的基本用法
fun chapter1BasicCoroutines() {
    println("\n===== 协程的基本用法 =====")

    // 启动一个协程
    runBlocking { // 这是一个挂起函数，需要在协程中调用
        val job = launch { // 启动一个协程
            delay(1000) // 模拟耗时操作
            println("协程执行完成")
        }

        println("协程已启动")
        job.join() // 等待协程执行完成
    }
}

// 挂起函数
fun chapter2SuspendFunctions() {
    println("\n===== 挂起函数 =====")

    runBlocking {
        val result = async {
            delay(1000)
            "Hello, Kotlin Coroutines"
        }

        println("结果: ${result.await()}")
    }
}

// 协程上下文和调度器
fun chapter3CoroutineContextAndDispatchers() {
    println("\n===== 协程上下文和调度器 =====")

    runBlocking {
        // 默认调度器
        launch {
            println("默认调度器: ${Thread.currentThread().name}")
        }

        // 指定调度器
        launch(Dispatchers.IO) {
            println("IO 调度器: ${Thread.currentThread().name}")
        }

        // 自定义调度器
        val customDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
        launch(customDispatcher) {
            println("自定义调度器: ${Thread.currentThread().name}")
        }

        delay(100) // 等待其他协程执行
    }
}

// 协程的作用域
fun chapter4CoroutineScope() {
    println("\n===== 协程的作用域 =====")

    // 创建一个协程作用域
    val scope = CoroutineScope(Dispatchers.Main)

    scope.launch {
        println("协程作用域中的协程: ${Thread.currentThread().name}")
    }

    // 使用 runBlocking 来保持主线程存活
    runBlocking {
        delay(100) // 等待协程执行
    }
}

// 异常处理
fun chapter5ExceptionHandling() {
    println("\n===== 异常处理 =====")

    runBlocking {
        val job = launch {
            try {
                delay(1000)
                throw RuntimeException("协程中抛出的异常")
            } catch (e: Exception) {
                println("捕获到异常: ${e.message}")
            }
        }

        job.join()
    }
}

// 协程中的并发和并行
fun chapter6ConcurrencyAndParallelism() {
    println("\n===== 协程中的并发和并行 =====")

    runBlocking {
        val startTime = System.currentTimeMillis()

        // 并发执行两个协程
        val deferred1 = async { performTask("任务 1") }
        val deferred2 = async { performTask("任务 2") }

        val result1 = deferred1.await()
        val result2 = deferred2.await()

        println("任务 1 结果: $result1")
        println("任务 2 结果: $result2")
        println("总耗时: ${System.currentTimeMillis() - startTime} ms")
    }
}

// 模拟一个耗时任务
suspend fun performTask(name: String): String {
    delay(1000)
    return "$name 完成"
}